home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / sunrpc / xprt.h < prev   
C/C++ Source or Header  |  2005-10-13  |  7KB  |  230 lines
  1. /*
  2.  *  linux/include/linux/sunrpc/clnt_xprt.h
  3.  *
  4.  *  Declarations for the RPC transport interface.
  5.  *
  6.  *  Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  7.  */
  8.  
  9. #ifndef _LINUX_SUNRPC_XPRT_H
  10. #define _LINUX_SUNRPC_XPRT_H
  11.  
  12. #include <linux/uio.h>
  13. #include <linux/socket.h>
  14. #include <linux/in.h>
  15. #include <linux/sunrpc/sched.h>
  16. #include <linux/sunrpc/xdr.h>
  17.  
  18. /*
  19.  * The transport code maintains an estimate on the maximum number of out-
  20.  * standing RPC requests, using a smoothed version of the congestion
  21.  * avoidance implemented in 44BSD. This is basically the Van Jacobson
  22.  * congestion algorithm: If a retransmit occurs, the congestion window is
  23.  * halved; otherwise, it is incremented by 1/cwnd when
  24.  *
  25.  *    -    a reply is received and
  26.  *    -    a full number of requests are outstanding and
  27.  *    -    the congestion window hasn't been updated recently.
  28.  *
  29.  * Upper procedures may check whether a request would block waiting for
  30.  * a free RPC slot by using the RPC_CONGESTED() macro.
  31.  */
  32. extern unsigned int xprt_udp_slot_table_entries;
  33. extern unsigned int xprt_tcp_slot_table_entries;
  34.  
  35. #define RPC_MIN_SLOT_TABLE    (2U)
  36. #define RPC_DEF_SLOT_TABLE    (16U)
  37. #define RPC_MAX_SLOT_TABLE    (128U)
  38.  
  39. #define RPC_CWNDSHIFT        (8U)
  40. #define RPC_CWNDSCALE        (1U << RPC_CWNDSHIFT)
  41. #define RPC_INITCWND        RPC_CWNDSCALE
  42. #define RPC_MAXCWND(xprt)    ((xprt)->max_reqs << RPC_CWNDSHIFT)
  43. #define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
  44.  
  45. /* Default timeout values */
  46. #define RPC_MAX_UDP_TIMEOUT    (60*HZ)
  47. #define RPC_MAX_TCP_TIMEOUT    (600*HZ)
  48.  
  49. /*
  50.  * Wait duration for an RPC TCP connection to be established.  Solaris
  51.  * NFS over TCP uses 60 seconds, for example, which is in line with how
  52.  * long a server takes to reboot.
  53.  */
  54. #define RPC_CONNECT_TIMEOUT    (60*HZ)
  55.  
  56. /*
  57.  * Delay an arbitrary number of seconds before attempting to reconnect
  58.  * after an error.
  59.  */
  60. #define RPC_REESTABLISH_TIMEOUT    (15*HZ)
  61.  
  62. /* RPC call and reply header size as number of 32bit words (verifier
  63.  * size computed separately)
  64.  */
  65. #define RPC_CALLHDRSIZE        6
  66. #define RPC_REPHDRSIZE        4
  67.  
  68. /*
  69.  * This describes a timeout strategy
  70.  */
  71. struct rpc_timeout {
  72.     unsigned long        to_initval,        /* initial timeout */
  73.                 to_maxval,        /* max timeout */
  74.                 to_increment;        /* if !exponential */
  75.     unsigned int        to_retries;        /* max # of retries */
  76.     unsigned char        to_exponential;
  77. };
  78.  
  79. /*
  80.  * This describes a complete RPC request
  81.  */
  82. struct rpc_rqst {
  83.     /*
  84.      * This is the user-visible part
  85.      */
  86.     struct rpc_xprt *    rq_xprt;        /* RPC client */
  87.     struct xdr_buf        rq_snd_buf;        /* send buffer */
  88.     struct xdr_buf        rq_rcv_buf;        /* recv buffer */
  89.  
  90.     /*
  91.      * This is the private part
  92.      */
  93.     struct rpc_task *    rq_task;    /* RPC task data */
  94.     __u32            rq_xid;        /* request XID */
  95.     int            rq_cong;    /* has incremented xprt->cong */
  96.     int            rq_received;    /* receive completed */
  97.     u32            rq_seqno;    /* gss seq no. used on req. */
  98.  
  99.     struct list_head    rq_list;
  100.  
  101.     struct xdr_buf        rq_private_buf;        /* The receive buffer
  102.                              * used in the softirq.
  103.                              */
  104.     unsigned long        rq_majortimeo;    /* major timeout alarm */
  105.     unsigned long        rq_timeout;    /* Current timeout value */
  106.     unsigned int        rq_retries;    /* # of retries */
  107.     /*
  108.      * For authentication (e.g. auth_des)
  109.      */
  110.     u32            rq_creddata[2];
  111.     
  112.     /*
  113.      * Partial send handling
  114.      */
  115.     
  116.     u32            rq_bytes_sent;    /* Bytes we have sent */
  117.  
  118.     unsigned long        rq_xtime;    /* when transmitted */
  119.     int            rq_ntrans;
  120. };
  121. #define rq_svec            rq_snd_buf.head
  122. #define rq_slen            rq_snd_buf.len
  123.  
  124. #define XPRT_LAST_FRAG        (1 << 0)
  125. #define XPRT_COPY_RECM        (1 << 1)
  126. #define XPRT_COPY_XID        (1 << 2)
  127. #define XPRT_COPY_DATA        (1 << 3)
  128.  
  129. struct rpc_xprt {
  130.     struct socket *        sock;        /* BSD socket layer */
  131.     struct sock *        inet;        /* INET layer */
  132.  
  133.     struct rpc_timeout    timeout;    /* timeout parms */
  134.     struct sockaddr_in    addr;        /* server address */
  135.     int            prot;        /* IP protocol */
  136.  
  137.     unsigned long        cong;        /* current congestion */
  138.     unsigned long        cwnd;        /* congestion window */
  139.  
  140.     unsigned int        rcvsize,    /* socket receive buffer size */
  141.                 sndsize;    /* socket send buffer size */
  142.  
  143.     struct rpc_wait_queue    sending;    /* requests waiting to send */
  144.     struct rpc_wait_queue    resend;        /* requests waiting to resend */
  145.     struct rpc_wait_queue    pending;    /* requests in flight */
  146.     struct rpc_wait_queue    backlog;    /* waiting for slot */
  147.     struct list_head    free;        /* free slots */
  148.     struct rpc_rqst *    slot;        /* slot table storage */
  149.     unsigned int        max_reqs;    /* total slots */
  150.     unsigned long        sockstate;    /* Socket state */
  151.     unsigned char        shutdown   : 1,    /* being shut down */
  152.                 nocong       : 1,    /* no congestion control */
  153.                 resvport   : 1, /* use a reserved port */
  154.                 stream     : 1;    /* TCP */
  155.  
  156.     /*
  157.      * XID
  158.      */
  159.     __u32            xid;        /* Next XID value to use */
  160.  
  161.     /*
  162.      * State of TCP reply receive stuff
  163.      */
  164.     u32            tcp_recm,    /* Fragment header */
  165.                 tcp_xid,    /* Current XID */
  166.                 tcp_reclen,    /* fragment length */
  167.                 tcp_offset;    /* fragment offset */
  168.     unsigned long        tcp_copied,    /* copied to request */
  169.                 tcp_flags;
  170.     /*
  171.      * Connection of sockets
  172.      */
  173.     struct work_struct    sock_connect;
  174.     unsigned short        port;
  175.     /*
  176.      * Disconnection of idle sockets
  177.      */
  178.     struct work_struct    task_cleanup;
  179.     struct timer_list    timer;
  180.     unsigned long        last_used;
  181.  
  182.     /*
  183.      * Send stuff
  184.      */
  185.     spinlock_t        sock_lock;    /* lock socket info */
  186.     spinlock_t        xprt_lock;    /* lock xprt info */
  187.     struct rpc_task *    snd_task;    /* Task blocked in send */
  188.  
  189.     struct list_head    recv;
  190.  
  191.  
  192.     void            (*old_data_ready)(struct sock *, int);
  193.     void            (*old_state_change)(struct sock *);
  194.     void            (*old_write_space)(struct sock *);
  195.  
  196.     wait_queue_head_t    cong_wait;
  197. };
  198.  
  199. #ifdef __KERNEL__
  200.  
  201. struct rpc_xprt *    xprt_create_proto(int proto, struct sockaddr_in *addr,
  202.                     struct rpc_timeout *toparms);
  203. int            xprt_destroy(struct rpc_xprt *);
  204. void            xprt_set_timeout(struct rpc_timeout *, unsigned int,
  205.                     unsigned long);
  206.  
  207. void            xprt_reserve(struct rpc_task *);
  208. int            xprt_prepare_transmit(struct rpc_task *);
  209. void            xprt_transmit(struct rpc_task *);
  210. void            xprt_receive(struct rpc_task *);
  211. int            xprt_adjust_timeout(struct rpc_rqst *req);
  212. void            xprt_release(struct rpc_task *);
  213. void            xprt_connect(struct rpc_task *);
  214. void            xprt_sock_setbufsize(struct rpc_xprt *);
  215.  
  216. #define XPRT_LOCKED    0
  217. #define XPRT_CONNECT    1
  218. #define XPRT_CONNECTING    2
  219.  
  220. #define xprt_connected(xp)        (test_bit(XPRT_CONNECT, &(xp)->sockstate))
  221. #define xprt_set_connected(xp)        (set_bit(XPRT_CONNECT, &(xp)->sockstate))
  222. #define xprt_test_and_set_connected(xp)    (test_and_set_bit(XPRT_CONNECT, &(xp)->sockstate))
  223. #define xprt_test_and_clear_connected(xp) \
  224.                     (test_and_clear_bit(XPRT_CONNECT, &(xp)->sockstate))
  225. #define xprt_clear_connected(xp)    (clear_bit(XPRT_CONNECT, &(xp)->sockstate))
  226.  
  227. #endif /* __KERNEL__*/
  228.  
  229. #endif /* _LINUX_SUNRPC_XPRT_H */
  230.